/**
 * 动态并发控制配置
 * 根据系统负载自动调整前端并发数
 */

import { getApiBaseUrl } from './env';

export interface SystemLoadInfo {
    // 系统负载信息
    queueLength: number;           // 队列长度
    activeServers: number;         // 活跃服务器数量
    averageResponseTime: number;   // 平均响应时间(ms)
    serverCapacity: number;        // 服务器总容量
    usedCapacity: number;          // 已使用容量
    scalingStatus: 'scaling_out' | 'scaling_in' | 'stable'; // 扩缩容状态
}

export interface ConcurrencyConfig {
    // 基础配置
    minConcurrency: number;        // 最小并发数
    maxConcurrency: number;        // 最大并发数
    baseConcurrency: number;       // 基础并发数

    // 动态调整参数
    queueThresholds: {
        low: number;               // 低负载队列阈值
        medium: number;            // 中等负载队列阈值
        high: number;              // 高负载队列阈值
    };

    responseTimeThresholds: {
        fast: number;              // 快速响应时间阈值(ms)
        normal: number;            // 正常响应时间阈值(ms)
        slow: number;              // 慢响应时间阈值(ms)
    };

    // 调整策略
    adjustmentStrategy: {
        aggressive: number;        // 激进调整系数
        conservative: number;      // 保守调整系数
        cooldownPeriod: number;    // 调整冷却期(ms)
    };
}

export const DYNAMIC_CONCURRENCY_CONFIG: ConcurrencyConfig = {
    // 基础配置 - 基于性能测试优化
    minConcurrency: 5,    // 提高最小并发数
    maxConcurrency: 50,   // 提高最大并发数
    baseConcurrency: 10,  // 提高基础并发数

    // 动态调整参数 - 基于实际性能优化
    queueThresholds: {
        low: 2,        // 队列长度 < 2 为低负载
        medium: 5,     // 队列长度 2-5 为中等负载
        high: 10       // 队列长度 > 10 为高负载
    },

    responseTimeThresholds: {
        fast: 0.1,     // < 100ms为快速响应，基于实际平均31ms
        normal: 0.2,   // 100-200ms为正常响应
        slow: 0.5      // > 500ms为慢响应
    },

    // 调整策略
    adjustmentStrategy: {
        aggressive: 1.5,      // 激进调整：并发数 * 1.5
        conservative: 0.8,    // 保守调整：并发数 * 0.8
        cooldownPeriod: 5000  // 5秒调整冷却期
    }
};

/**
 * 动态并发控制器
 */
export class DynamicConcurrencyController {
    private currentConcurrency: number;
    private lastAdjustmentTime: number = 0;
    private config: ConcurrencyConfig;

    constructor(config: ConcurrencyConfig = DYNAMIC_CONCURRENCY_CONFIG) {
        this.config = config;
        this.currentConcurrency = config.baseConcurrency;
    }

    /**
     * 根据系统负载计算最优并发数
     */
    calculateOptimalConcurrency(loadInfo: SystemLoadInfo): number {
        const now = Date.now();

        // 检查冷却期
        if (now - this.lastAdjustmentTime < this.config.adjustmentStrategy.cooldownPeriod) {
            return this.currentConcurrency;
        }

        let newConcurrency = this.currentConcurrency;

        // 基于队列长度的调整
        newConcurrency = this.adjustByQueueLength(newConcurrency, loadInfo.queueLength);

        // 基于响应时间的调整
        newConcurrency = this.adjustByResponseTime(newConcurrency, loadInfo.averageResponseTime);

        // 基于服务器容量的调整
        newConcurrency = this.adjustByServerCapacity(newConcurrency, loadInfo);

        // 基于扩缩容状态的调整
        newConcurrency = this.adjustByScalingStatus(newConcurrency, loadInfo.scalingStatus);

        // 应用边界限制
        newConcurrency = Math.max(this.config.minConcurrency,
            Math.min(this.config.maxConcurrency, newConcurrency));

        // 如果并发数发生变化，更新调整时间
        if (newConcurrency !== this.currentConcurrency) {
            this.lastAdjustmentTime = now;
            this.currentConcurrency = newConcurrency;

            console.log(`🔄 动态调整并发数: ${this.currentConcurrency} (队列:${loadInfo.queueLength}, 响应:${loadInfo.averageResponseTime}ms, 服务器:${loadInfo.activeServers})`);
        }

        return this.currentConcurrency;
    }

    /**
     * 基于队列长度调整并发数
     */
    private adjustByQueueLength(current: number, queueLength: number): number {
        if (queueLength < this.config.queueThresholds.low) {
            // 低负载：减少并发数，避免过度请求
            return Math.floor(current * this.config.adjustmentStrategy.conservative);
        } else if (queueLength > this.config.queueThresholds.high) {
            // 高负载：增加并发数，加快处理
            return Math.ceil(current * this.config.adjustmentStrategy.aggressive);
        }
        return current;
    }

    /**
     * 基于响应时间调整并发数
     */
    private adjustByResponseTime(current: number, responseTime: number): number {
        if (responseTime < this.config.responseTimeThresholds.fast) {
            // 响应很快：可以增加并发数
            return Math.ceil(current * 1.2);
        } else if (responseTime > this.config.responseTimeThresholds.slow) {
            // 响应很慢：减少并发数，避免系统过载
            return Math.floor(current * this.config.adjustmentStrategy.conservative);
        }
        return current;
    }

    /**
     * 基于服务器容量调整并发数
     */
    private adjustByServerCapacity(current: number, loadInfo: SystemLoadInfo): number {
        const capacityRatio = loadInfo.usedCapacity / loadInfo.serverCapacity;

        if (capacityRatio < 0.3) {
            // 容量充足：可以增加并发数
            return Math.ceil(current * 1.3);
        } else if (capacityRatio > 0.8) {
            // 容量紧张：减少并发数
            return Math.floor(current * 0.7);
        }
        return current;
    }

    /**
     * 基于扩缩容状态调整并发数
     */
    private adjustByScalingStatus(current: number, scalingStatus: string): number {
        switch (scalingStatus) {
            case 'scaling_out':
                // 正在扩容：可以增加并发数
                return Math.ceil(current * 1.2);
            case 'scaling_in':
                // 正在缩容：减少并发数，避免触发新的扩容
                return Math.floor(current * 0.8);
            case 'stable':
            default:
                return current;
        }
    }

    /**
     * 获取当前并发数
     */
    getCurrentConcurrency(): number {
        return this.currentConcurrency;
    }

    /**
     * 重置并发数到基础值
     */
    reset(): void {
        this.currentConcurrency = this.config.baseConcurrency;
        this.lastAdjustmentTime = 0;
    }
}

// 全局动态并发控制器实例
export const dynamicConcurrencyController = new DynamicConcurrencyController();

/**
 * 获取动态并发数
 * 这个函数会被前端调用，根据系统负载返回最优并发数
 */
export const getDynamicConcurrency = async (): Promise<number> => {
    try {
        // 从HAI优化系统获取负载信息
        const response = await fetch('https://www.gongjuxiang.work/api/v1/system/status');
        if (!response.ok) {
            console.warn('无法获取系统状态，使用默认并发数');
            return DYNAMIC_CONCURRENCY_CONFIG.baseConcurrency;
        }

        const systemStatus = await response.json();

        // 构建负载信息
        const loadInfo: SystemLoadInfo = {
            queueLength: systemStatus.data?.queue?.total_tasks_in_queue || 0,
            activeServers: systemStatus.data?.servers?.available || 0,
            averageResponseTime: systemStatus.data?.servers?.average_response_time || 5000,
            serverCapacity: systemStatus.data?.servers?.total_capacity || 10,
            usedCapacity: systemStatus.data?.servers?.used_capacity || 0,
            scalingStatus: systemStatus.data?.scaling?.status || 'stable'
        };

        // 计算最优并发数
        return dynamicConcurrencyController.calculateOptimalConcurrency(loadInfo);

    } catch (error) {
        console.error('获取动态并发数失败:', error);
        return DYNAMIC_CONCURRENCY_CONFIG.baseConcurrency;
    }
};
